home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / magazine / msysjour / vol04 / 01a / genapp / applcatn.c next >
C/C++ Source or Header  |  1988-10-24  |  21KB  |  934 lines
  1. /***************************************************************
  2.     APPLCATN.C 
  3. ****************************************************************/    
  4.  
  5. #ifdef AS
  6. #include <memory.h>
  7. #endif
  8.  
  9. #include "CONFIG.H"
  10.  
  11. #include "STDDEFS.H"
  12. #include "APPLCATN.H"
  13. #include "ENVRNMT.H"
  14.  
  15. /****************************************************************/
  16.  
  17. PUBLIC VOID app_MainProcedure() 
  18. {
  19.     if(    env_InitEnvironment() 
  20.         && app_InitApplication()
  21.       )
  22.     {
  23.         while(app_EventLoop())
  24.             /*continue*/;
  25.     }
  26. }
  27.  
  28.  
  29. /****************************************************************/
  30.  
  31. LOCAL BOOL app_InitApplication()    
  32. {
  33.     if( app_InitCommandDispatcher()
  34.         && vu_InitViews()
  35.         && doc_InitDocuments()
  36. #ifdef MAC
  37. #ifdef DBG
  38.         && ut_InitDebugModule()
  39.         && ut_CreateDebugMenu()
  40. #endif
  41.         /*&& vu_NewView("Untitled",(Rect *)NULL, doc_NewDocument(), GRAPHICS_VIEW)*/
  42. #endif        
  43.         )
  44.             return TRUE;
  45.     /*else*/
  46.     return FALSE;
  47. }
  48.  
  49. /****************************************************************/
  50. #ifdef DBG
  51. LOCAL STRING app_events[] =
  52. {
  53.     "NULL_EVENT","QUIT_EVENT","CMD_EVENT","MOUSEDOWN_EVENT",
  54.     "MOUSEUP_EVENT","OPENVIEW_EVENT","CLOSEVIEW_EVENT",
  55.     "MOVEVIEW_EVENT","RESIZEVIEW_EVENT","ACTIVATEVIEW_EVENT",
  56.     "UPDATEVIEW_EVENT",    "CHAR_EVENT"
  57. };
  58. #endif
  59.  
  60. LOCAL BOOL app_EventLoop()
  61. {
  62.     APPEVENT        theEvent;
  63.     
  64.     env_GetAppEvent(&theEvent);
  65.     
  66.     ut_PutString("RV|appEventLoop: appevent",
  67.         app_events[theEvent.event_type]);
  68.  
  69.     switch (theEvent.event_type)
  70.     {
  71.         case QUIT_EVENT:
  72.         {
  73.             return FALSE;
  74.         } break;
  75.         
  76.         case CMD_EVENT: 
  77.         {
  78.             app_DispatchCommand( theEvent.cmd_category, 
  79.                             theEvent.cmd_item ); 
  80.         } break;
  81.             
  82.         case MOUSEDOWN_EVENT:
  83.         {
  84.             INDEX vu = vu_WhichView(theEvent.canvas);
  85.             if (vu != INVALID_INDEX)
  86.                     vu_MouseDown(vu, &theEvent.where);
  87.         } break;
  88.     
  89.         case OPENVIEW_EVENT:
  90.         {
  91.             INDEX vu = vu_WhichView(theEvent.canvas);
  92.             if (vu != INVALID_INDEX)
  93.                     vu_OpenView(vu);
  94.         } break;
  95.                 
  96.         case CLOSEVIEW_EVENT:
  97.         {
  98.             INDEX vu = vu_WhichView(theEvent.canvas);
  99.             if (vu != INVALID_INDEX)
  100.                 vu_CloseView(vu);
  101.         } break;
  102.                 
  103.         case MOVEVIEW_EVENT:
  104.         {
  105.             INDEX vu = vu_WhichView(theEvent.canvas);
  106.             if (vu != INVALID_INDEX)
  107.             {
  108.                 vu_MoveView(vu, &theEvent.where);
  109.             }
  110.         } break;
  111.                 
  112.  
  113.         case RESIZEVIEW_EVENT:
  114.         {
  115.             INDEX vu = vu_WhichView(theEvent.canvas);
  116.             if (vu != INVALID_INDEX)
  117.                     vu_ResizeView( vu, &theEvent.where );
  118.         } break;
  119.                 
  120.         case CHAR_EVENT:                    
  121.         {
  122.             if(theEvent.the_char=='x') 
  123.                 env_FatalError("X means quit program.");
  124.         } break;
  125.  
  126.         case ACTIVATEVIEW_EVENT:
  127.         {
  128.             INDEX vu = vu_WhichView( theEvent.canvas );
  129.             
  130.             if(vu != INVALID_INDEX)
  131.             {
  132.                 vu_ActivateView(vu);            
  133.                 vu_InvalidateView(vu); /*generate update*/
  134.             }
  135.         }    break;
  136.         
  137.         case UPDATEVIEW_EVENT:
  138.         {
  139.             INDEX vu = vu_WhichView( theEvent.canvas );
  140.     
  141.             ut_Print2Shorts("RV|appEventLoop: vu,canvas",
  142.                     vu,theEvent.canvas);
  143.             if(vu != INVALID_INDEX)
  144.             {
  145.                 vu_UpdateView( vu );
  146.             }
  147.         } break;
  148.         
  149.     } /*end switch*/
  150.     return TRUE;
  151. }
  152.  
  153.  
  154. /****************************************************************
  155.     OBJECT MANAGER
  156. ****************************************************************/    
  157.  
  158.  
  159. PUBLIC VOID obj_HighlightObjAsGraphics(canvas, obj)
  160.     HCANVAS        canvas;
  161.     POBJ         obj;
  162. {
  163.     Rect r;
  164.     r = obj->rect; /*structure copy */
  165.     env_StartDrawing(canvas);
  166.     switch(obj->objtype)
  167.     {
  168.         case RECT_OBJ: env_FillRect(canvas,&r,PATT_GRAY);
  169.                 break;
  170.         case OVAL_OBJ: env_PaintRect(canvas,&r); break;
  171.     }
  172.     env_EndDrawing(canvas);
  173. }
  174.  
  175. PUBLIC VOID obj_ShowObjAsGraphics(canvas, obj)
  176.     HCANVAS    canvas;
  177.     POBJ    obj;
  178. {
  179.     Rect r;
  180.     r = obj->rect; /*structure copy */
  181.     env_StartDrawing(canvas);    
  182.     switch(obj->objtype)
  183.     {
  184.         case RECT_OBJ: env_FrameRect(canvas,&r); break;
  185.         case OVAL_OBJ: env_FrameRect(canvas,&r); break;
  186.     }
  187.     env_EndDrawing(canvas);
  188. }
  189.  
  190. PUBLIC VOID obj_MakeObject(obj, r, type, attr)
  191.     POBJ     obj;
  192.     Rect *    r;
  193.     ENUM    type,attr;
  194. {
  195.     obj->rect    = *r; /*structure copy */
  196.     obj->objtype = type; 
  197.     obj->objattr = attr;
  198. }
  199.  
  200. PUBLIC VOID obj_ShowObjAsText( canvas, x,y,obj)
  201.     HCANVAS        canvas;
  202.     PIXEL        x,y;
  203.     POBJ         obj;
  204. {
  205.     env_StartDrawing(canvas);    
  206.     switch(obj->objtype)
  207.     {
  208.         case RECT_OBJ: env_TextOut(canvas,x,y,"RECTANGLE"); break;
  209.         case OVAL_OBJ: env_TextOut(canvas,x,y,"OVAL"); break;
  210.     }
  211.     env_EndDrawing(canvas);
  212. }
  213.  
  214.         
  215. /****************************************************************
  216.     DATA MODEL MANAGER (contains objects)
  217. ****************************************************************/    
  218.  
  219.  
  220. PUBLIC HMODEL mod_NewModel()
  221. {
  222.     HMODEL h;
  223.     PMODEL m;
  224.     h = (HMODEL) env_AllocMem( (MEMSIZE) sizeof(int));
  225.     m = (PMODEL) env_GraspMem(h);
  226.     m->num_objects = 0;
  227.     env_UnGraspMem(h);
  228.     return h;
  229. }
  230.     
  231. PUBLIC OBJID mod_AddObjectToModel( model, r, type,attr)
  232.     HMODEL *model;
  233.     Rect *    r;
  234.     ENUM    type,attr;
  235. {
  236.     INDEX    i;
  237.     PMODEL    m;
  238.     int    num_objects;
  239.  
  240.     m = (PMODEL) env_GraspMem(*model);
  241.     num_objects = ++(m->num_objects);
  242.  
  243.     env_UnGraspMem(*model);
  244.     
  245.     env_ReAllocMem( (MEMBLOCK *) model, 
  246.             (MEMSIZE) (sizeof(int) + (num_objects * sizeof(OBJ))));
  247.     
  248.     m = (PMODEL) env_GraspMem(*model);
  249.     i = m->num_objects-1;
  250.     ut_PrintShort(  "RV|modAddObj: obj#",i);
  251.     ut_PrintMacRect("RV|modAddObj: rect",r);    
  252.     obj_MakeObject((POBJ) &(m->objects[i]), r, type, attr);
  253.     env_UnGraspMem(*model);
  254.     return i;
  255. }
  256.  
  257. PUBLIC VOID mod_HighlightObjAsGraphics( canvas, model, obj)
  258.     HCANVAS    canvas;
  259.     HMODEL        model;
  260.     OBJID        obj;
  261. {
  262.     PMODEL        m;
  263.     
  264.     m = (PMODEL) env_GraspMem(model);
  265.     obj_HighlightObjAsGraphics(canvas, (POBJ) &(m->objects[obj]));
  266.     env_UnGraspMem(model);
  267. }
  268.  
  269. PUBLIC VOID mod_ShowObjAsGraphics( canvas, model, obj)
  270.     HCANVAS        canvas;
  271.     HMODEL        model;
  272.     OBJID        obj;
  273. {
  274.     PMODEL         m;
  275.     m = (PMODEL) env_GraspMem(model);
  276.     obj_ShowObjAsGraphics(canvas, (POBJ) &(m->objects[obj]));
  277.     env_UnGraspMem(model);
  278. }
  279.  
  280. PUBLIC VOID mod_ShowModelAsGraphics( canvas, model)
  281.     HCANVAS        canvas;
  282.     HMODEL        model;
  283. {
  284.     PMODEL    m;
  285.     INDEX    i;
  286.     m = (PMODEL) env_GraspMem(model);
  287.     for(i=0; i < m->num_objects; i++)
  288.     {
  289.         obj_ShowObjAsGraphics(canvas, (POBJ) &(m->objects[i]) );
  290.     }
  291.     env_UnGraspMem(model);
  292. }
  293.  
  294.  
  295. PUBLIC VOID mod_ShowModelAsText( canvas, model,rect,linespace,left_margin)
  296.     HCANVAS    canvas;
  297.     HMODEL        model;
  298.     Rect *        rect;
  299.     PIXEL        linespace,left_margin;
  300. {
  301.     PMODEL        m;
  302.     INDEX        i;
  303.     PIXEL        x,y;
  304.  
  305.     ut_PrintMacRect("RV|mdShowModelAsText: rect",rect);
  306.  
  307.     m = (PMODEL) env_GraspMem(model);
  308.     x = rect->left + left_margin;
  309.     y = rect->top;
  310.     
  311.     for(i=0; i < m->num_objects; i++)
  312.     {
  313.         y += linespace;
  314.         if( y > rect->bottom) y = rect->top + linespace;
  315.         obj_ShowObjAsText( canvas, x, y, (POBJ) &(m->objects[i]));
  316.     }
  317.     env_UnGraspMem(model);
  318. }
  319.  
  320. PUBLIC VOID mod_ShowObjAsText( canvas, model, obj, rect, linespace, left_margin)
  321.     HCANVAS canvas;
  322.     HMODEL    model;
  323.     OBJID    obj;
  324.     Rect *    rect;
  325.     PIXEL    linespace,left_margin;
  326. {
  327.     PMODEL    m;
  328.     INDEX    i;
  329.     PIXEL    x,y;
  330.     
  331.     m = (PMODEL) env_GraspMem(model);
  332.     x = rect->left + left_margin;
  333.     y = rect->top;
  334.     
  335.     for(i=0; i < m->num_objects; i++)
  336.     {
  337.         y += linespace;
  338.         if( y > rect->bottom) y = rect->top + linespace;
  339.         if(obj==i) 
  340.             obj_ShowObjAsText( canvas, x,y, (POBJ) &(m->objects[i]));
  341.     }
  342.     env_UnGraspMem(model);
  343. }
  344.  
  345. PUBLIC OBJID mod_DetectHitInTextMode( model,where, rect, linespace, left_margin)
  346.     HMODEL    model;
  347.     Point *    where;
  348.     Rect *    rect;
  349.     PIXEL    linespace,left_margin;
  350. {
  351.     PMODEL    m;
  352.     INDEX    i;
  353.     PIXEL    x,y;
  354.     
  355.     m = (PMODEL) env_GraspMem(model);
  356.     x = rect->left + left_margin;
  357.     y = rect->top;
  358.     
  359.     for(i=0; i < m->num_objects; i++)
  360.     {
  361.         y += linespace;
  362.         if( y > rect->bottom) y = rect->top + linespace;
  363.         if(y > where->v)
  364.         {
  365.             env_UnGraspMem(model);
  366.             return MAX(0,i-1);
  367.         }
  368.     }
  369.     env_UnGraspMem(model);
  370.     return MAX(0, m->num_objects - 1);
  371. }    
  372.     
  373.     
  374. PUBLIC OBJID mod_DetectHitInGraphicsMode( model,where)
  375.     HMODEL    model;
  376.     Point *    where;
  377. {
  378.     PMODEL    m;
  379.     INDEX    i;
  380.     m = (PMODEL) env_GraspMem(model);
  381.     for(i=0; i < m->num_objects; i++)
  382.     {
  383.         if(env_PtInRect(where,(pRect) &(m->objects[i].rect)))
  384.         {
  385.             env_UnGraspMem(model);
  386.             return (OBJID) i;
  387.         }
  388.     }
  389.     env_UnGraspMem(model);
  390.     return INVALID_OBJID;
  391. }
  392.  
  393.  
  394.  
  395. /****************************************************************
  396.     DOCUMENT MANAGER
  397.     Each document contains a data model and multiple
  398.     views to that data model.
  399. ****************************************************************/    
  400.  
  401.  
  402. LOCAL DOC theSetOfDocuments[MAX_DOCUMENTS];
  403.  
  404.  
  405. PUBLIC BOOL doc_InitDocuments()
  406. {
  407.     REG DOC *p;
  408.     int i;
  409.     
  410.     for(p = theSetOfDocuments; p < &theSetOfDocuments[MAX_DOCUMENTS]; p++)
  411.     {
  412.         p->in_use = p->is_modified = FALSE;
  413.         for(i=0; i < VIEWS_PER_DOC; i++) p->views[i] = INVALID_INDEX;
  414.         p->model = INVALID_MODEL;
  415.     }
  416.     return TRUE;
  417. }
  418.  
  419. LOCAL INDEX allocate_document()
  420. {
  421.     REG DOC *p;
  422.     for(p = theSetOfDocuments; p < &theSetOfDocuments[MAX_DOCUMENTS]; p++)
  423.     {
  424.         if( !p->in_use )
  425.         {
  426.             p->in_use        = TRUE;
  427.             p->is_modified    = FALSE;
  428.             p->model        = mod_NewModel();
  429.             if(p->model==INVALID_MODEL) return INVALID_INDEX;
  430.             return (INDEX) (p - theSetOfDocuments);
  431.         }
  432.     }
  433.     /*not found*/
  434.     return INVALID_INDEX;
  435. }
  436.  
  437. PUBLIC INDEX doc_NewDocument()
  438. {
  439.     INDEX i = allocate_document();
  440.     if(i==INVALID_INDEX) env_FatalError("NewDoc: allocate doc failed!");
  441.     return i;
  442. }
  443.  
  444. PUBLIC BOOL doc_AddViewToDoc( doc, vu)
  445.     INDEX doc,vu;
  446. {
  447.     DOC *p = &theSetOfDocuments[doc];
  448.     int i;
  449.     for(i = 0; i < VIEWS_PER_DOC; i++)
  450.     {
  451.         if(p->views[i] == INVALID_INDEX) break;
  452.     }
  453.     if(p->views[i] != INVALID_INDEX) return FALSE;
  454.     p->views[i] = vu;
  455.     return TRUE;
  456. }
  457.  
  458. PUBLIC OBJID doc_AddObjectToDocument( doc, r, type, attr)
  459.     INDEX doc;
  460.     Rect *r;
  461.     ENUM type;
  462.     ENUM attr;
  463. {
  464.     DOC *p = &theSetOfDocuments[doc];
  465.     int i;
  466.  
  467.     ut_PrintShort("RV|AddObj: doc#",doc);
  468.  
  469.     p->is_modified = TRUE;
  470.     for(i = 0; i < VIEWS_PER_DOC; i++)
  471.     {
  472.         if(p->views[i] != INVALID_INDEX) vu_InvalidateView(p->views[i]);
  473.     }
  474.     return mod_AddObjectToModel( &(p->model),r,type,attr);
  475. }
  476.  
  477.  
  478. /*****************************************************************
  479.     DOC routines which invoke the display of data model objects
  480. ****************************************************************/    
  481.  
  482. PUBLIC VOID doc_ShowObjAsGraphics( canvas, doc, obj) 
  483.     HCANVAS    canvas;
  484.     INDEX     doc;    /* called from MakeObj in graphics mode*/
  485.     OBJID    obj;
  486. {
  487.     mod_ShowObjAsGraphics(canvas, theSetOfDocuments[doc].model, obj);
  488.     
  489. }
  490.  
  491. PUBLIC VOID doc_HighlightObjAsGraphics( canvas, doc, obj) 
  492.     HCANVAS canvas;
  493.     INDEX     doc;        /* called from MakeObj in graphics mode*/
  494.     OBJID    obj;
  495. {
  496.     mod_HighlightObjAsGraphics(canvas, theSetOfDocuments[doc].model, obj);
  497.     
  498. }
  499.  
  500. PUBLIC VOID doc_ShowObjAsText( canvas, doc, obj, rect)
  501.     HCANVAS        canvas;
  502.     INDEX         doc;
  503.     OBJID        obj;
  504.     Rect *        rect;
  505. {
  506.     mod_ShowObjAsText(canvas, theSetOfDocuments[doc].model, obj, rect,
  507.                 10 /*linespace*/, 10 /*leftmargin*/);
  508.     
  509. }
  510.  
  511. PUBLIC VOID doc_ShowModelAsGraphics( canvas, doc) 
  512.     HCANVAS        canvas;
  513.     INDEX         doc;
  514. {
  515.     mod_ShowModelAsGraphics(canvas, theSetOfDocuments[doc].model);
  516.     
  517. }
  518.  
  519. PUBLIC VOID doc_ShowModelAsText( canvas, doc, rect) 
  520.     HCANVAS    canvas;
  521.     INDEX         doc;
  522.     Rect *        rect;
  523. {
  524.     mod_ShowModelAsText(canvas, theSetOfDocuments[doc].model, rect,
  525.                 10 /*linespace*/, 10 /*leftmargin*/);
  526. }
  527.  
  528. PUBLIC OBJID doc_DetectHitInGraphicsMode( doc, where)
  529.     INDEX     doc;
  530.     Point *    where;
  531. {
  532.     return mod_DetectHitInGraphicsMode(theSetOfDocuments[doc].model, where);
  533.     
  534. }
  535.  
  536.  
  537. /****************************************************************
  538.     VIEW MANAGER
  539.     Each view is connected to one canvas (drawing surface)
  540. *****************************************************************/    
  541.  
  542.  
  543. #include "view.h"    
  544.  
  545. LOCAL VIEW        theSetOfViews[MAX_VIEWS];
  546. LOCAL Rect        theWholeScreen; /*q:how about multiple screens? */
  547.  
  548. LOCAL INDEX        theCurrentView;
  549. LOCAL ENUM        theCurrentVuMode;
  550.  
  551. /*values for VuMode*/
  552. #define SELECTION_MODE        0
  553. #define CREATE_RECT_MODE    1
  554. #define CREATE_OVAL_MODE    2
  555.  
  556.  
  557. PUBLIC BOOL vu_InitViews()
  558. {
  559.     REG VIEW *p;
  560.     
  561.     for(p = theSetOfViews; p < &theSetOfViews[MAX_VIEWS]; p++)    
  562.     {
  563.         p->in_use    = FALSE;
  564.         p->document = INVALID_INDEX;
  565.         p->viewtype     = NULL;
  566.     }
  567.     theCurrentView = INVALID_INDEX;
  568.     theCurrentVuMode = CREATE_RECT_MODE;
  569.     
  570.     env_GetScreenSize(&theWholeScreen);
  571.     return TRUE;
  572. }
  573.  
  574.  
  575. PUBLIC INDEX vu_WhichView(canvas)
  576.     HCANVAS canvas;
  577. {
  578.     REG VIEW *p;
  579.     
  580.     for(p = theSetOfViews; p < &theSetOfViews[MAX_VIEWS]; p++)    
  581.     {
  582.         if(p->in_use && p->canvas==canvas)
  583.             return (INDEX)(p - theSetOfViews);
  584.     }
  585.     return INVALID_INDEX;
  586. }
  587.  
  588. #ifdef MAC    /*this may no longer be needed for Mac */
  589. PUBLIC BOOL vu_IsAppView(devdata)
  590.     LONG devdata;
  591. {
  592.     return env_IsDevData(devdata);
  593. }
  594. #endif
  595.  
  596. PUBLIC INDEX vu_WhichDocument(vu)
  597.     INDEX vu;
  598. {
  599. #ifdef AS
  600. #else
  601.     REG VIEW *p;
  602. #endif
  603.     return theSetOfViews[vu].document;
  604. }
  605.  
  606. PUBLIC INDEX vu_TheCurrentView()
  607. {
  608.     return theCurrentView;
  609. }
  610.  
  611. LOCAL INDEX allocate_view()
  612. {
  613.     VIEW *p;
  614.     for(p = theSetOfViews; p < &theSetOfViews[MAX_VIEWS]; p++)
  615.     {
  616.         if( !p->in_use )
  617.         {
  618.             p->in_use = TRUE;
  619.             p->document  = INVALID_INDEX;
  620.             p->viewtype  = NULL;
  621.             return (INDEX) (p - theSetOfViews);
  622.         }
  623.     }
  624.     /*not found*/
  625.     return INVALID_INDEX;
  626. }
  627.  
  628. PUBLIC VOID vu_SetCurrentView()
  629. {
  630. #ifdef MACXXXX /*move to environment.c*/
  631.     if(theCurrentView != INVALID_INDEX)
  632.         SetPort((GrafPtr) &(theSetOfViews[theCurrentView].window_record));
  633. #endif
  634. }
  635.  
  636. PUBLIC INDEX vu_NewView(title, rect, doc, viewtype)
  637.     STRING    title;
  638.     Rect *    rect;
  639.     INDEX    doc;
  640.     ENUM    viewtype;
  641. {
  642.     INDEX        vu;
  643.     Rect        r;
  644.     
  645.     if(rect==(Rect *)NULL) /*compute size of window*/
  646.     {
  647.         r = theWholeScreen; /*structure copy */
  648.         r.top        += 50;
  649.         r.left        += 20;
  650.         r.bottom    = r.top + DEPTH_RECT(&theWholeScreen)/2;
  651.         r.right        -= 40;
  652.     }
  653.     
  654.     if( (vu=allocate_view()) ==INVALID_INDEX) 
  655.         env_FatalError("NewView: create new view failed!");
  656.  
  657.     theSetOfViews[vu].canvas   = env_NewCanvas( (long) vu);
  658.     theSetOfViews[vu].document = doc;
  659.     theSetOfViews[vu].viewtype = viewtype;
  660.  
  661.     if(!doc_AddViewToDoc(doc,vu)) env_FatalError("NewView: AddView failed!");
  662.  
  663.     theCurrentView = vu;
  664.  
  665.     if( !env_NewWindow( title, &r, vu, theSetOfViews[vu].canvas) )
  666.            env_FatalError("NewView: envNewWindow failed!");
  667.     vu_SetCurrentView();
  668.     return TRUE;                
  669. }
  670.  
  671. PUBLIC VOID vu_SetSelectionMode() {theCurrentVuMode = SELECTION_MODE; }
  672. PUBLIC VOID vu_SetCreateRectMode() {theCurrentVuMode = CREATE_RECT_MODE; }
  673. PUBLIC VOID vu_SetCreateOvalMode() {theCurrentVuMode = CREATE_OVAL_MODE; }
  674.  
  675.     
  676. /****** OPERATIONS ON OBJECTS WITHIN A VIEW ********/
  677.  
  678. LOCAL VOID vu_DetectHitInGraphicsMode(vu, where)    
  679.     INDEX vu; Point * where;
  680. {
  681.     OBJID        obj;
  682.     
  683.     env_GlobalToLocal( theSetOfViews[vu].canvas, where );
  684.     obj = doc_DetectHitInGraphicsMode(theSetOfViews[vu].document,where);
  685.     if(obj != INVALID_OBJID)
  686.         doc_HighlightObjAsGraphics(theSetOfViews[vu].canvas,
  687.                 theSetOfViews[vu].document, obj);
  688. }
  689.  
  690. LOCAL VOID vu_MakeObjInGraphicsMode(vu, where)    
  691.     INDEX vu; Point * where;
  692. {
  693.     Rect            r;
  694.     OBJID            obj;
  695.     
  696.  
  697.     env_GlobalToLocal(theSetOfViews[vu].canvas, where );
  698.  
  699.     r.top = where->v; r.left = where->h;
  700.     r.bottom = r.top + 10;
  701.     r.right  = r.left +10;
  702.     
  703.     obj = doc_AddObjectToDocument(theSetOfViews[vu].document, &r, 
  704.                         RECT_OBJ, FRAME_ATTR);
  705.     if(obj==INVALID_OBJID) env_FatalError("AddObject failed!");
  706.     doc_ShowObjAsGraphics(theSetOfViews[vu].canvas, 
  707.                         theSetOfViews[vu].document, obj);
  708. }
  709.  
  710. LOCAL VOID vu_MakeObjInTextMode(vu, where)    
  711.     INDEX vu; Point * where;
  712. {
  713. #ifdef MACXXXX    /*to fix up*/
  714.     HCANVAS        canvas = (HCANVAS) &(theSetOfViews[vu].window_record);
  715.     Rect        r;
  716.     OBJID        obj;
  717.     
  718.     env_GlobalToLocal(theSetOfViews[vu].canvas, where );
  719.     r.top = where->v; r.left = where->h;
  720.     r.bottom = r.top + 10;
  721.     r.right  = r.left +10;
  722.     
  723.     obj = doc_AddObjectToDocument(theSetOfViews[vu].document, &r, RECT_OBJ, FRAME_ATTR);
  724.     if(obj==INVALID_OBJID) env_FatalError("AddObject failed!");
  725.     doc_ShowObjAsText(canvas, theSetOfViews[vu].document, obj, &(canvas->portRect));
  726. #endif
  727. }
  728.  
  729.     
  730. PUBLIC VOID vu_MouseDown(vu, where)
  731.     INDEX vu; Point *where; 
  732. {
  733.     Point pt;
  734.     pt = *where; /*structure copy */
  735.  
  736.     if(theSetOfViews[vu].viewtype==GRAPHICS_VIEW)
  737.     {
  738.         switch(theCurrentVuMode)
  739.         {
  740.             case SELECTION_MODE:
  741.             {
  742.                 vu_DetectHitInGraphicsMode(vu,&pt); 
  743.             } break;
  744.             case CREATE_RECT_MODE:
  745.             case CREATE_OVAL_MODE:
  746.             {
  747.                 vu_MakeObjInGraphicsMode(vu, &pt);
  748.             } break;
  749.         }
  750.     }
  751.     else if (theSetOfViews[vu].viewtype==TEXT_VIEW)
  752.     {
  753.         switch(theCurrentVuMode)
  754.         {
  755. #if 0 /*to be done*/
  756.             case SELECTION_MODE:
  757.             {
  758.                 vu_DetectHitInTextMode(vu,&pt); 
  759.             } break;
  760.             case CREATE_RECT_MODE:
  761.             case CREATE_OVAL_MODE:
  762.             {
  763.                 vu_make_a_rectangle(vu, &pt);
  764.             } break;
  765. #endif
  766.         }
  767.     }
  768.     
  769. }
  770.  
  771. /****************************************************************
  772.     OPERATIONS ON VIEWS: move, resize, close, invalidate, update
  773. ****************************************************************/    
  774.  
  775. PUBLIC VOID vu_ActivateView(vu)
  776.     INDEX    vu;
  777. {
  778.     env_ActivateCanvas( theSetOfViews[vu].canvas );
  779. }
  780.  
  781. PUBLIC VOID vu_InvalidateView(vu)
  782.     INDEX    vu;
  783. {
  784.     env_InvalidateCanvas( theSetOfViews[vu].canvas, (Rect*)NULL );
  785. }
  786.  
  787. PUBLIC VOID vu_CloseView(vu)
  788.     INDEX vu;
  789. {
  790.     env_FatalError("CloseView called!"); /*to be done*/
  791. }
  792.  
  793. PUBLIC VOID vu_OpenView(vu)
  794.     INDEX vu;
  795. {
  796.     env_CalcSizeCanvas(theSetOfViews[vu].canvas);    
  797. }
  798.  
  799. PUBLIC VOID vu_ResizeView(vu,where) 
  800.     INDEX vu; Point *where;
  801. {
  802.     env_ResizeCanvas(theSetOfViews[vu].canvas,where);
  803.     env_CalcSizeCanvas(theSetOfViews[vu].canvas);
  804. }
  805.  
  806. PUBLIC VOID vu_MoveView(vu,where)
  807.     INDEX vu; Point *where;
  808. {
  809.     env_MoveCanvas(vu,where);
  810.     env_CalcSizeCanvas(theSetOfViews[vu].canvas);    
  811. }
  812.  
  813. PUBLIC VOID vu_UpdateView(vu)
  814.     INDEX    vu;
  815. {
  816.     HCANVAS    canvas = theSetOfViews[vu].canvas;
  817. #ifdef AS
  818. #else
  819.     Rect    rect;
  820. #endif
  821.  
  822.     ut_Print2Shorts("RV|vu_UpdateView: ENTRY view# doc#",
  823.             vu,theSetOfViews[vu].document);
  824.     
  825.     env_BeginUpdate( canvas );
  826.     
  827.     if(theSetOfViews[vu].viewtype==GRAPHICS_VIEW)
  828.     {
  829.         doc_ShowModelAsGraphics(canvas, theSetOfViews[vu].document);
  830.     }
  831.     else if (theSetOfViews[vu].viewtype==TEXT_VIEW)
  832.     {
  833. #if 0 /*to be done*/
  834.         doc_ShowModelAsText(canvas, theSetOfViews[vu].document,
  835.                 &(canvas->portRect));
  836. #endif
  837.     }
  838.     env_EndUpdate( canvas );
  839.     ut_PrintShort("RV|vu_UpdateView: EXIT canvas#",canvas);
  840. }
  841.  
  842. /****************************************************************
  843.     COMMAND DISPATCHER
  844. *****************************************************************/
  845.  
  846. #include "dispatch.h"
  847.  
  848. LOCAL BOOL app_InitCommandDispatcher() 
  849. {
  850.     if(env_InitMenus())
  851.     return TRUE;
  852.     /*else*/
  853.     return FALSE;
  854. }
  855.  
  856.  
  857. LOCAL VOID app_DispatchCommand( menu_category, menu_item )
  858.     int        menu_category, menu_item;
  859. {
  860.     ut_Print2Shorts("RV|appDispatchCmd: category,item",
  861.                     menu_category,menu_item);
  862.     switch (menu_category) 
  863.     {
  864.         case R_ID_SYS_MENU:
  865.         {
  866.             env_DoSysMenu(menu_item);
  867.         } break;
  868.         
  869.         case R_ID_FILE_MENU: 
  870.         {
  871.             switch(menu_item)
  872.             {
  873.                 case FILE_CMD_NEW:
  874.                 {
  875.                     vu_NewView("Untitled",(Rect *)NULL, doc_NewDocument(), GRAPHICS_VIEW);
  876.                 } break;
  877.                 
  878.                 case FILE_CMD_OPEN:    env_NotImplemented("FIle Open"); break;
  879.                 case FILE_CMD_CLOSE:    env_NotImplemented("FIle Close"); break;
  880.                 case FILE_CMD_SAVE:    env_NotImplemented("FIle Save"); break;
  881.                 case FILE_CMD_SAVE_AS:    env_NotImplemented("FIle SaveAs"); break;
  882.                 case FILE_CMD_REVERT:    env_NotImplemented("FIle Revert"); break;
  883.                 case FILE_CMD_PAGE_SETUP:
  884.                 case FILE_CMD_PRINT:
  885.                 case FILE_CMD_QUIT:
  886.                 default: ;
  887.             }
  888.         } break;
  889.         
  890. #if 0 /*to be done*/
  891.         case R_ID_EDIT_MENU: 
  892.         {
  893.             if (SystemEdit(menu_item - 1)==0) 
  894.             {
  895.                 switch (menu_item) 
  896.                 {
  897.                 case EDIT_CMD_CUT:        TECut(    TEH );    dirty = TRUE;    break;
  898.                 case EDIT_CMD_COPY:        TECopy(   TEH );                    break;
  899.                 case EDIT_CMD_PASTE:    TEPaste(  TEH );    dirty = TRUE;    break;
  900.                 case EDIT_CMD_CLEAR:    TEDelete( TEH );    dirty = TRUE;    break;
  901.                 default: ;
  902.                 }
  903.                 ShowSelect();
  904.             }
  905.         } break;
  906.  
  907.         case R_ID_VIEW_MENU: 
  908.         {
  909.             switch(menu_item)
  910.             {
  911.             case VIEW_CMD_TEXT_VIEW: vu_NewView("Text View",(Rect *)NULL,
  912.                                     vu_WhichDocument(vu_TheCurrentView()),TEXT_VIEW);  
  913.                                         break;
  914.             case VIEW_CMD_GRAPHICS_VIEW: vu_NewView("Graphics View",(Rect *)NULL,
  915.                                     vu_WhichDocument(vu_TheCurrentView()),GRAPHICS_VIEW);  
  916.             }
  917.             HiliteMenu(0);
  918.         } break;
  919. #endif        
  920.  
  921.         case R_ID_PALETTE_MENU: 
  922.         {
  923.             switch(menu_item)
  924.             {
  925.                 case PALETTE_SELECTION_MODE:vu_SetSelectionMode(); break;
  926.                 case PALETTE_CREATE_RECT_MODE:vu_SetCreateRectMode(); break;
  927.             }
  928. #ifdef MAC
  929.             HiliteMenu(0);
  930. #endif            
  931.         } break;
  932.     } /*outer-switch*/
  933. }
  934.